// /**
//  * ViewComponent 使用示例
//  * 
//  * 展示新的懒加载策略的各种使用场景
//  * 
//  * @author AI Assistant
//  * @date 2025-11-29
//  */

// import { ecs } from "../../../core/ecs/ECS";
// import { ViewComponent, ViewComponentType } from "./ViewComponent";
// import { Color, Component, _decorator } from "cc";

// const { ccclass } = _decorator;

// // ==================== 示例 1：基础使用（自动懒加载）====================

// /**
//  * 基础渲染系统
//  * 使用懒加载，无需任何配置
//  */
// @ecs.register('BasicRender')
// export class BasicRenderSystem extends ecs.ComblockSystem implements ecs.ISystemUpdate {
//     filter(): ecs.IMatcher {
//         return ecs.allOf(ViewComponent);
//     }
    
//     update(entity: ecs.Entity): void {
//         const view = entity.get(ViewComponent);
        
//         // ✅ 第一次访问：自动缓存（~2-5 μs）
//         // ✅ 后续访问：极快（~2-5 ns）
//         if (view.sprite) {
//             view.sprite.color = Color.RED;
//         }
        
//         if (view.label) {
//             view.label.string = 'Hello World';
//         }
//     }
// }

// // ==================== 示例 2：组件类型检查优化 ====================

// /**
//  * 物理渲染系统
//  * 使用组件类型检查，避免无效访问
//  */
// @ecs.register('PhysicsRender')
// export class PhysicsRenderSystem extends ecs.ComblockSystem implements ecs.ISystemUpdate {
//     filter(): ecs.IMatcher {
//         return ecs.allOf(ViewComponent);
//     }
    
//     update(entity: ecs.Entity): void {
//         const view = entity.get(ViewComponent);
        
//         // ✅ 快速检查：避免访问不存在的组件
//         if (!view.hasComponentType(ViewComponentType.PHYSICS)) {
//             return;
//         }
        
//         // 现在可以安全访问物理组件
//         if (view.rigidbody) {
//             console.log('Velocity:', view.rigidbody.linearVelocity);
//         }
        
//         if (view.collider) {
//             console.log('Collider enabled:', view.collider.enabled);
//         }
//     }
// }

// // ==================== 示例 3：自定义组件（类型安全）====================

// /**
//  * 自定义健康条组件
//  */
// @ccclass('HealthBar')
// export class HealthBar extends Component {
//     private currentHealth: number = 100;
//     private maxHealth: number = 100;
    
//     updateHealth(value: number): void {
//         this.currentHealth = value;
//         // 更新 UI
//     }
    
//     getHealthPercent(): number {
//         return this.currentHealth / this.maxHealth;
//     }
// }

// /**
//  * 健康系统
//  * 展示如何使用自定义组件
//  */
// @ecs.register('Health')
// export class HealthSystem extends ecs.ComblockSystem implements ecs.ISystemUpdate {
//     filter(): ecs.IMatcher {
//         return ecs.allOf(ViewComponent);
//     }
    
//     update(entity: ecs.Entity): void {
//         const view = entity.get(ViewComponent);
        
//         // ✅ 类型安全的方式（推荐）
//         const healthBar = view.getCustomComponent(HealthBar);
//         if (healthBar) {
//             healthBar.updateHealth(80);  // ✅ 有类型提示
//             const percent = healthBar.getHealthPercent();
//             console.log('Health:', percent);
//         }
        
//         // ⚠️ 字符串方式（不推荐，无类型安全）
//         // const healthBar2 = view.getCustomComponentByName<HealthBar>('HealthBar');
//     }
// }

// // ==================== 示例 4：预加载优化 ====================

// /**
//  * 批量创建实体并预加载组件
//  */
// export class EntityFactory {
//     /**
//      * 创建敌人实体
//      * 
//      * 场景：如果你确定敌人都需要 Sprite 和 Animation，
//      * 可以预加载这些组件以优化首次访问性能
//      */
//     async createEnemies(count: number, sceneCoordinator: any): Promise<ecs.Entity[]> {
//         const enemies: ecs.Entity[] = [];
        
//         for (let i = 0; i < count; i++) {
//             // 创建实体
//             const entity = ecs.getEntity(ecs.Entity);
            
//             // 创建视图
//             const node = await sceneCoordinator.instantiatePrefab(
//                 'game',
//                 'prefabs/enemy',
//                 { layerName: 'game' }
//             );
            
//             // 初始化 ViewComponent（懒加载模式）
//             const view = new ViewComponent();
//             view.init(node);
            
//             // ✅ 可选：预加载已知需要的组件
//             view.preloadComponents([
//                 ViewComponentType.RENDER_2D,  // Sprite, Label
//                 ViewComponentType.ANIMATION   // Animation
//             ]);
            
//             entity.add(view);
//             enemies.push(entity);
//         }
        
//         return enemies;
//     }
    
//     /**
//      * 创建 UI 元素
//      * 
//      * UI 元素通常只需要 UITransform 和 Label
//      */
//     async createUIElements(count: number, sceneCoordinator: any): Promise<ecs.Entity[]> {
//         const uiElements: ecs.Entity[] = [];
        
//         for (let i = 0; i < count; i++) {
//             const entity = ecs.getEntity(ecs.Entity);
            
//             const node = await sceneCoordinator.instantiatePrefab(
//                 'game',
//                 'prefabs/ui_element',
//                 { layerName: 'ui' }
//             );
            
//             const view = new ViewComponent();
//             view.init(node);
            
//             // ✅ 只预加载 UI 相关组件
//             view.preloadComponents([
//                 ViewComponentType.UI,         // UITransform
//                 ViewComponentType.RENDER_2D   // Label
//             ]);
            
//             entity.add(view);
//             uiElements.push(entity);
//         }
        
//         return uiElements;
//     }
// }

// // ==================== 示例 5：性能对比测试 ====================

// /**
//  * 性能测试工具
//  */
// export class ViewComponentPerformanceTest {
//     /**
//      * 测试懒加载性能
//      */
//     static testLazyLoading(): void {
//         console.log('=== ViewComponent 懒加载性能测试 ===');
        
//         const iterations = 1000;
        
//         // 模拟节点（实际使用时替换为真实节点）
//         const mockNode = {
//             isValid: true,
//             active: true,
//             name: 'TestNode',
//             getComponent: (type: any) => null
//         } as any;
        
//         // 测试 1：初始化性能
//         console.log('\n测试 1：初始化 1000 个 ViewComponent');
//         const initStart = performance.now();
//         const views: ViewComponent[] = [];
        
//         for (let i = 0; i < iterations; i++) {
//             const view = new ViewComponent();
//             view.init(mockNode);  // ✅ 零开销初始化
//             views.push(view);
//         }
        
//         const initTime = performance.now() - initStart;
//         console.log(`初始化耗时: ${initTime.toFixed(2)}ms`);
//         console.log(`平均每个: ${(initTime / iterations * 1000).toFixed(2)}μs`);
        
//         // 测试 2：首次访问性能
//         console.log('\n测试 2：首次访问 sprite（触发缓存）');
//         const firstAccessStart = performance.now();
        
//         for (const view of views) {
//             const sprite = view.sprite;  // 第一次访问，触发 getComponent
//         }
        
//         const firstAccessTime = performance.now() - firstAccessStart;
//         console.log(`首次访问耗时: ${firstAccessTime.toFixed(2)}ms`);
//         console.log(`平均每个: ${(firstAccessTime / iterations * 1000).toFixed(2)}μs`);
        
//         // 测试 3：后续访问性能
//         console.log('\n测试 3：后续访问 sprite（命中缓存）');
//         const cachedAccessStart = performance.now();
        
//         for (let j = 0; j < 10; j++) {
//             for (const view of views) {
//                 const sprite = view.sprite;  // 命中缓存，极快
//             }
//         }
        
//         const cachedAccessTime = performance.now() - cachedAccessStart;
//         console.log(`缓存访问耗时 (10 次循环): ${cachedAccessTime.toFixed(2)}ms`);
//         console.log(`平均每个: ${(cachedAccessTime / iterations / 10 * 1000000).toFixed(2)}ns`);
        
//         // 测试 4：组件类型检查性能
//         console.log('\n测试 4：组件类型检查性能');
//         const typeCheckStart = performance.now();
        
//         for (let j = 0; j < 10; j++) {
//             for (const view of views) {
//                 const hasRender = view.hasComponentType(ViewComponentType.RENDER_2D);
//                 const hasPhysics = view.hasComponentType(ViewComponentType.PHYSICS);
//             }
//         }
        
//         const typeCheckTime = performance.now() - typeCheckStart;
//         console.log(`类型检查耗时 (10 次循环): ${typeCheckTime.toFixed(2)}ms`);
//         console.log(`平均每个: ${(typeCheckTime / iterations / 10 * 1000000).toFixed(2)}ns`);
        
//         console.log('\n=== 测试完成 ===');
//     }
    
//     /**
//      * 测试内存使用
//      */
//     static testMemoryUsage(): void {
//         console.log('=== ViewComponent 内存使用测试 ===');
        
//         const iterations = 10000;
//         const mockNode = {
//             isValid: true,
//             active: true,
//             name: 'TestNode',
//             getComponent: (type: any) => null
//         } as any;
        
//         // 测试：懒加载模式的内存占用
//         console.log('\n创建 10000 个 ViewComponent（懒加载）');
        
//         // @ts-ignore
//         if (performance.memory) {
//             // @ts-ignore
//             const beforeMemory = performance.memory.usedJSHeapSize;
            
//             const views: ViewComponent[] = [];
//             for (let i = 0; i < iterations; i++) {
//                 const view = new ViewComponent();
//                 view.init(mockNode);
//                 views.push(view);
//             }
            
//             // @ts-ignore
//             const afterMemory = performance.memory.usedJSHeapSize;
//             const memoryUsed = (afterMemory - beforeMemory) / 1024 / 1024;
            
//             console.log(`内存占用: ${memoryUsed.toFixed(2)} MB`);
//             console.log(`平均每个: ${(memoryUsed / iterations * 1024 * 1024).toFixed(2)} bytes`);
//         } else {
//             console.log('⚠️ 浏览器不支持 performance.memory API');
//         }
        
//         console.log('\n=== 测试完成 ===');
//     }
// }

// // ==================== 示例 6：实际使用场景 ====================

// /**
//  * 游戏角色系统
//  * 展示真实游戏场景中的使用
//  */
// @ecs.register('Character')
// export class CharacterSystem extends ecs.ComblockSystem implements ecs.ISystemUpdate {
//     filter(): ecs.IMatcher {
//         return ecs.allOf(ViewComponent);
//     }
    
//     update(entity: ecs.Entity): void {
//         const view = entity.get(ViewComponent);
        
//         // ✅ 场景 1：更新角色外观
//         if (view.sprite) {
//             // 根据状态改变颜色
//             const health = 80; // 从其他组件获取
//             if (health < 30) {
//                 view.sprite.color = Color.RED;
//             } else if (health < 60) {
//                 view.sprite.color = Color.YELLOW;
//             } else {
//                 view.sprite.color = Color.WHITE;
//             }
//         }
        
//         // ✅ 场景 2：更新名称标签
//         if (view.label) {
//             view.label.string = 'Player';
//         }
        
//         // ✅ 场景 3：播放动画
//         if (view.animation) {
//             view.playAnimation('walk', true);
//         }
        
//         // ✅ 场景 4：更新自定义组件
//         const healthBar = view.getCustomComponent(HealthBar);
//         if (healthBar) {
//             healthBar.updateHealth(80);
//         }
        
//         // ✅ 场景 5：物理交互
//         if (view.hasComponentType(ViewComponentType.PHYSICS)) {
//             if (view.rigidbody) {
//                 // 应用力
//                 // view.rigidbody.applyForceToCenter(new Vec2(10, 0), true);
//             }
//         }
//     }
// }

// // ==================== 导出测试函数 ====================

// /**
//  * 运行所有性能测试
//  */
// export function runViewComponentTests(): void {
//     ViewComponentPerformanceTest.testLazyLoading();
//     ViewComponentPerformanceTest.testMemoryUsage();
// }

// /**
//  * 使用说明：
//  * 
//  * 1. 在游戏启动时可以运行性能测试：
//  *    runViewComponentTests();
//  * 
//  * 2. 创建实体时使用 EntityFactory：
//  *    const factory = new EntityFactory();
//  *    const enemies = await factory.createEnemies(100, sceneCoordinator);
//  * 
//  * 3. 在系统中使用 ViewComponent：
//  *    - 直接访问组件（自动懒加载）
//  *    - 使用组件类型检查优化
//  *    - 使用类型安全的自定义组件 API
//  */

